Black FridayUp to 80% OFF

Search in scripts for " TABLE "

Multiple Indicator 50EMA Cross AlertsHere’s a screener including Symbol, Price, TSI, and 50 ema cross in a table output. The 50 Exponential Moving Average is a trend indicator You can find bullish momentum when the 50 ema crossed over or a bearish momentum when the 50 ema crossed under we are looking to take advantage by trading the reversion of these trends. True strength index (TSI) is a trend momentum indicator Readings are bullish when the True Strength Index shows positive values Readings are bearish when the indicator displays negative values. When a value is above 20, we look for selling overbought opportunity and when the value is under 20, we look for buying oversold opportunity. You can select the pair of your choice in the settings. Make sure to create an alert and choose any alerts then an alert will trigger when a price cross under or cross over the 50 ema for every pair separately. This allow the user to verify if there is a trade set up or not. Disclaimer This post and the script don’t provide any financial advice.
Pine Script® indicator
by F_rank_01
27
BTC Futures BasisShows various basis percentages in a table and plots historical basis. Also has an alert function for backwardation events. Useful for tracking bullish/bearish sentiment in BTC futures markets. *Currently displays March and June futures for the following exchanges: Bitmex, Binance, Deribit, Okex, and FTX Also displays CME Continuous Next Contract. All of the symbols are customizable. ----------- Market-wide backwardation usually occurs during a heavy sell-off (such as a liquidation cascade). **For getting alerts of backwardation events, I recommend creating an alert on the 1 minute chart with the condition "Any alert() function call". Alert level is customizable as well. ----------- *NOTE!! : Futures contracts expire (obviously), so the contract symbols will need to be updated periodically. I will try to keep them updated going into the future. **NOTE2!! : The alert() function does not track the CME contract. This is to avoid false triggers.
Pine Script® indicator
by daylad
4
SPY Sub-Sector Daily Money Flow TableThis calculates the dollar volume per candlestick (2nd row) and cumulative (3rd row) of the entire trading day for each subsector of the SPY. The 'Total' column is the total of all the subsectors combined. It is calculated separately from SPY volume. The money flow is calculated with (open+close)/2 which means different timeframes yield different results and won't be especially accurate day-by-day. This is useful to quickly see rotation and possible divergences. Enjoy!
Pine Script® indicator
by barnabygraham
6
[CLX][#01] Animation - Price Ticker (Marquee)This indicator displays a classic animated price ticker overlaid on the user’s current chart. It is possible to fully customize it or to select one of the predefined styles. A detailed description will follow in the next few days. Used Pinescript technics: - varip (view/animation) - tulip instance (config/codestructur) - table (view/position) By the way, for me, one of the coolest animated effects is by Duyck We hope you enjoy it! 🎉 CRYPTOLINX - jango_blockchained 😊👍 Disclaimer: Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely. The script is for informational and educational purposes only. Use of the script does not constitute professional and/or financial advice. You alone have the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold dgtrd TradingView user liable for any possible claim for damages arising from any decision you make based on use of the script.
Pine Script® indicator
by cryptolinx
2
MTF Price/Volume % [Anan]Hello friends, This is a multi-timeframe table with these features: Display price change percentage compared with the last timeframe candle close. Display price change percentage compared with the last timeframe candle close MA. Displays change percentage compared with the last timeframe candle volume. Displays change percentage compared with the last timeframe candle volume MA. Change type/length of MA for Price/Volume. Full control of Panel position and size. Full control of displaying any row or column.
Pine Script® indicator
by Mohamed3nan
20
Average Daily Range TableThis is the last script to complete Vladimir Poltoratskiy's setup found in his books. Poltoratskiy argues that you should not take any fractal corridors higher than 50% of the Average Daily Range. To be honest, even 40% is a lot, because then, your target will be 160% ADR away from your entry and one "fracture" just can't be enough to predict moves this big. I chose a table to visually represent the indicator because it doesn't change its value during the day. It takes far less room on the chart. There are also two simple moving averages. You may use the as an indicator if the relative volatility as of late is extremely low and in that case, perhaps, expect an increase in the coming days. They are applied to the Average Daily Range, not one day range!
Pine Script® indicator
by OrcChieftain
1
PAC newThis indicator will alert you when a candle goes above or below the price action channel (PAC) but only on the first or second candle after a colour change in candle. When price is above the price action channel that is a bullish sign, when price is below the PAC that is a bearish sign. The idea is that a sudden change in price is a cause to investigate further price action moving in that direction so the indicator aims to identify reversal Scalping strategy that works on 5 min chart and aims to gain 10 pips. Do not act on every signal. Further investigation is required, for example by looking at RSI oversolf and overbought levels. For example, at an oversold area, a buy signal is more valid
Pine Script® indicator
by table47
Month/Month Percentage % Change, Historical; Seasonal TendencyTable of monthly % changes in Average Price over the last 10 years (or the 10 yrs prior to input year). Useful for gauging seasonal tendencies of an asset; backtesting monthly volatility and bullish/bearish tendency. ~~User Inputs~~ Choose measure of average: sma(close), sma(ohlc4), vwap(close), vwma(close). Show last 10yrs, with 10yr average % change, or to just show single year. Chose input year; with the indicator auto calculating the prior 10 years. Choose color for labels and size for labels; choose +Ve value color and -Ve value color. Set 'Daily bars in month': 21 for Forex/Commodities/Indices; 30 for Crypto. Set precision: decimal places ~~notes~~ -designed for use on Daily timeframe (tradingview is buggy on monthly timeframe calculations, and less precise on weekly timeframe calculations). -where Current month of year has not occurred yet, will print 9yr average. -calculates the average change of displayed month compared to the previous month: i.e. Jan22 value represents whole of Jan22 compared to whole of Dec21. -table displays on the chart over the input year; so for ES, with 2010 selected; shows values from 2001-2010, displaying across 2010-2011 on the chart. -plots on seperate right hand side scale, so can be shrunk and dragged vertically. -thanks to @gabx11 for the suggestion which inspired me to write this
Pine Script® indicator
by twingall
10
投資の運勢※日本語説明文は英文の下にあります。 This indicator is a dashboard that simplifies the market’s current condition as a “fortune” by comprehensively evaluating the strength of multiple technical indicators. It allows you to check important analytical results at a glance without cluttering the chart with unnecessary lines. 🎯 How it works: Quantifying and integrating multiple indicators At the core of this indicator is the process of quantifying four key aspects of the market—trend, momentum, volatility, and volume—assigning weights to each, and calculating an overall score. How to use it This indicator functions as a table (dashboard) displayed on your chart. Check your “fortune for today” to get an overall view of the market’s current risk-reward profile. Analyze the rows for each indicator to understand the factors behind the fortune. For example: “The fortune is ‘moderately favorable,’ but volatility is very high (numerical value is large), which reduces the overall score due to its weighted impact.” The table uses white text on a dark background, making it easy to read regardless of the chart’s color scheme. ⚙️ Customization (Settings Panel) In the indicator’s settings panel, you can make the following key adjustments: Type of Moving Average: Turning on use_ema allows the trend calculation to use EMA (Exponential Moving Average). Weight Adjustment: You can adjust the weights of each indicator (e.g., w_trend, w_momentum) to modify the scoring logic according to your strategy (e.g., trend-focused, momentum-focused). Use this “fortune chart” as a supplementary tool to objectively assess the current market conditions, rather than as the final decision-maker for trades. ---------------ここから日本語説明-------------------------- このインジケーターは、複数のテクニカル指標の強さを総合的に評価し、現在の市場の状況を**「運勢」**としてシンプルに表示するダッシュボードです。チャート上に邪魔なラインを表示せず、重要な分析結果をひと目で確認できます。 🎯 仕組み：複数の指標を数値化して統合 このインジケーターの核となるのは、市場の4つの主要な側面（トレンド、モメンタム、ボラティリティ、出来高）を数値化し、それぞれに重み付けをして総合スコアを算出する点です。 活用方法 このインジケーターは、チャートに表示される**テーブル（ダッシュボード）**として機能します。 「今日の運勢」を確認し、現在の市場のリスク・リワードの全体像を把握します。 各指標の行を見て、運勢の根拠となった要素を分析します。 例：「運勢が中吉だが、ボラティリティが非常に高い（数値が大きい）ため、重みが働いてスコアが抑えられている」といった分析が可能です。 テーブルは文字が白で背景が暗い色に統一されているため、どの背景色でも見やすくなっています。 ⚙️ カスタマイズ（設定パネル） インジケーターの設定画面で、以下の重要な調整が可能です。 移動平均線の種類: use_ema をONにすると、トレンド計算に**EMA（指数移動平均）**を使用できます。 重み調整: 各指標の w_trend, w_momentum などを調整することで、ご自身の戦略（例：トレンド重視、モメンタム重視）に合わせてスコアの算出ロジックを変更できます。 この「占いチャート」を、トレード判断の最終決定ではなく、現状の市場を客観的に評価する補助ツールとしてご活用ください。
Pine Script® indicator
by mamachi-
Buy Sell SignalBuy Sell Signal - EMA Crossover with Dynamic Risk Management OVERVIEW This indicator combines a dual EMA crossover system with ATR-based dynamic stop loss and take profit levels to provide complete trade management signals. Unlike basic EMA crossover scripts, this tool automatically calculates and displays entry points, stop losses, and take profit targets based on market volatility, offering traders a complete trading framework in a single indicator. HOW IT WORKS The indicator uses three core components working together: Trend Detection: A fast EMA (default 5) and slow EMA (default 13) identify trend direction. When the fast EMA crosses above the slow EMA, it signals bullish momentum; when it crosses below, it signals bearish momentum. Entry Validation: Optional candle confirmation filter ensures the crossover is accompanied by a bullish/bearish candle close, reducing false signals in choppy markets. Risk Management: Uses ATR (Average True Range, default 14 periods) to calculate: Stop Loss: Positioned below/above recent swing low/high minus ATR multiplier (default 0.5x) Take Profit: Calculated using customizable risk-reward ratio (default 3:1) KEY FEATURES ✅ Automatic Position Tracking: Monitors active trades and displays current position status (LONG/SHORT/No position) ✅ Visual Trade Management: Shows entry price (white dashed line), stop loss (red line), and take profit (green line) in real-time ✅ Trade Outcome Signals: Displays clear markers when TP is hit (🎯), SL is triggered (❌), or position is invalidated by opposite signal ✅ Information Dashboard: Live table showing entry price, SL, TP, and actual R:R ratio ✅ Smart Position Invalidation: Automatically closes and invalidates previous positions when opposite trend signal appears ✅ Customizable Alerts: Five alert conditions for BUY/SELL signals, TP hits, SL triggers, and invalidations INPUTS Fast EMA Length (default 5): Responsive to recent price action Slow EMA Length (default 13): Defines broader trend direction ATR Period (default 14): Volatility measurement period SL Multiplier (default 0.5): Distance from swing point to stop loss Risk:Reward Ratio (default 3.0): Target profit relative to risk Candle Confirmation (default ON): Requires bullish/bearish candle on crossover HOW TO USE Apply the indicator to your chart (works on all timeframes) Adjust EMA periods based on your trading style (shorter for scalping, longer for swing trading) Set your preferred risk-reward ratio Enable alerts for automated notifications When a BUY/SELL signal appears, the indicator automatically calculates and displays your complete trade plan Monitor the information table for live position updates Exit when TP is reached or SL is triggered TRADING METHODOLOGY This script implements a momentum-following strategy based on exponential moving average crossovers, enhanced with volatility-adjusted risk parameters. The ATR-based stop loss adapts to market conditions—wider stops in volatile markets, tighter stops in calm markets. The position invalidation feature prevents traders from holding outdated positions when market sentiment shifts. BEST PRACTICES Use on trending markets for best results Higher timeframes (4H, Daily) produce fewer but more reliable signals. For scalpe use 5 and 15 minutes(Risk). Consider market context and fundamental factors alongside signals Adjust ATR multiplier based on asset volatility Test different EMA combinations for your preferred instruments ORIGINALITY While EMA crossover systems are common, this script's value lies in its complete integration of entry logic, dynamic risk management, position tracking, and automated invalidation—features typically requiring multiple separate indicators. The ATR-based stop loss calculation and automatic R:R visualization provide practical trade execution guidance that basic crossover indicators lack. Important Notes: This indicator does not guarantee profitable trades Always practice proper risk management Backtest settings on historical data before live trading Past performance does not indicate future results
Pine Script® indicator
by kelfry98
Grok/Claude AI Neural Fusion Pro * Grok/Claude X SeriesGrok/Claude AI Neural Fusion Pro This is a TradingView indicator that combines multiple technical analysis methods into a unified scoring system to identify trading opportunities. Despite the "Neural" and "AI" branding, it's not actually using machine learning — it's a sophisticated blend of traditional indicators weighted together to produce a single decision-aiding score. Core Philosophy The indicator attempts to answer the question: "How bullish or bearish is the current market environment, and when should I consider entering a trade?" It does this by calculating a "GXS Score" (ranging from -1 to +1) that aggregates five different market dimensions: trend strength, momentum, volume, price structure, and price action quality. Each dimension contributes to the final score based on user-defined weights. The Dynamic Bands System Rather than using standard Bollinger Bands, this indicator creates adaptive bands that expand and contract based on market conditions. The bands are built around a midpoint calculated from Heikin Ashi candles (smoothed price bars that filter out noise), then extended outward using ATR (Average True Range) multiplied by a dynamic factor. What makes these bands "dynamic" is that the multiplier adjusts based on two factors: the Chaikin Oscillator (which measures buying/selling pressure through accumulation/distribution) and ADX (trend strength). When there's strong directional pressure or a powerful trend, the bands widen to accommodate larger price swings. In quieter markets, they tighten. The Five Scoring Components The GXS Score is built from five weighted components: ComponentDefault WeightWhat It MeasuresTrend Strength30%ADX direction and magnitude — is there a real trend, and which way?Momentum25%RSI, MACD, Stochastic, CCI, Rate of Change, plus divergence detectionVolume20%On-Balance Volume slope and whether volume confirms price movementPrice Structure15%Where price sits within the bands, plus volatility regimePrice Action10%Ratio of bullish vs bearish candles over recent bars Trend Strength Component This component only contributes to the score when ADX indicates a trending market (above the threshold, default 24). If DI+ exceeds DI-, the score tilts bullish; if DI- dominates, it tilts bearish. In ranging markets, this component essentially zeros out, preventing false trend signals during choppy conditions. Momentum Component This is the most complex component, combining six sub-indicators. RSI is normalized around the 50 level. MACD histogram is standardized against its own volatility. Stochastic and CCI contribute bonus points at extreme levels (oversold/overbought). Rate of Change adds directional bias for strong moves. Finally, divergence detection looks for situations where price makes new highs/lows but RSI doesn't confirm — a classic reversal warning. Volume Component The indicator tracks On-Balance Volume (a cumulative measure of buying vs selling pressure) and compares it to its moving average. When OBV is rising above its average during an uptrend, that's confirmation. The volume rate of change also contributes — surging volume adds conviction to signals. Price Structure Component This measures where the current price sits within the dynamic bands. If price is in the bottom 20% of the band range, that's bullish (potential bounce zone). If it's in the top 20%, that's bearish (potential resistance). The component also factors in volatility regime — low volatility environments get a slight bullish bias (breakouts tend to follow compression), while high volatility gets a bearish bias (exhaustion risk). Price Action Component A simple measure of recent candle character. If 70%+ of the last 10 candles were bullish (closed higher than they opened), the score tilts positive. Heavy bearish candle dominance tilts it negative. Signal Generation Buy and sell signals are generated when price touches or breaches the dynamic bands, but only if several filters pass: ADX Filter (optional): Requires the market to be trending, avoiding signals in choppy conditions RSI Filter (optional): For buys, RSI must be oversold (below 30); for sells, RSI must be overbought (above 70) Cooldown Period: Prevents signal spam by requiring a minimum number of bars between signals (default 6) The indicator also tracks "zones" based purely on the GXS Score. When the score exceeds the buy threshold (default 0.12) during a trending market, a green cloud appears between the bands. When it drops below the sell threshold (default -0.12), a red cloud appears. These zones indicate favorable conditions even without a specific band-touch signal. Trend Strength Meter Separate from the GXS Score, the indicator calculates a "Trend Strength" percentage (0-100%) displayed in the info table. This combines ADX strength (40% weight), slope consistency (30% — how steady is the price direction), volume alignment (20% — is volume confirming the move), and momentum agreement (10% — are multiple indicators pointing the same direction). This helps traders gauge how reliable the current trend is. Visual Elements The indicator provides multiple visual layers that can be toggled on or off: Dynamic bands (blue midline, red upper, green lower) Signal clouds between the bands when in buy/sell zones Background shading indicating bullish (green) or bearish (red) regime Triangle arrows at signal points with configurable sizes Price labels showing exact entry prices at signals ADX strength dots at the bottom (white = weak, orange = moderate, blue = strong) Info table with current readings for all key metrics Debug panel (optional) showing individual component scores Summary This is essentially a "committee voting" system where multiple technical indicators each cast votes on market direction, and those votes are weighted and summed into a single score. The dynamic bands provide context for where price is relative to recent volatility, while the various filters help avoid low-quality signals. It's designed for traders who want a synthesized view of market conditions rather than watching a dozen separate indicators.
Pine Script® indicator
by ralis24
Grok/Claude MoneyLine Fusion * Grok/Claude X SeriesMoneyLine Fusion Indicator This is a technical analysis indicator designed to help traders identify potential buy and sell opportunities in the market. It combines several well-known trading concepts into one unified tool, displaying visual bands on the chart and generating signals when multiple conditions align. The Core Concept: The "Money Line" At the heart of this indicator is something called the Money Line, which is essentially a smoothed trend line calculated using linear regression over the last 16 bars (by default). Think of it as a "best fit" line through recent prices that shows you the general direction the market is heading. The indicator colors this line green when the trend is rising, red when it's falling, and yellow when it's essentially flat or undecided. The Dynamic Bands Surrounding the Money Line are upper and lower bands that expand and contract based on market volatility. These bands use the ATR (Average True Range) to measure how much the price typically moves. Here's where it gets clever: the bands also factor in the ADX indicator (which measures trend strength). When the market is trending strongly, the bands widen more aggressively to account for bigger price swings. When the trend is weak, they stay tighter. This adaptive behavior helps the indicator adjust to different market conditions automatically. The area between the bands is shaded in the trend color (green, red, or yellow) to give you a quick visual of the current market bias. How Buy and Sell Signals Are Generated The indicator doesn't just look at one thing — it requires multiple conditions to align before triggering a signal. This is designed to filter out false signals and only alert you when several factors agree. Signal TypeRequired ConditionsBUYFisher Transform is below -2.0 (oversold), Aroon Up is low (below 20), Aroon Down is high (above 80), and optionally a positive TA ScoreSELLFisher Transform is above +2.0 (overbought), Aroon Up is high (above 80), Aroon Down is low (below 20), and optionally a negative TA Score Fisher Transform is a mathematical technique that converts price data into a bell curve distribution, making extreme readings (overbought/oversold) easier to spot. Aroon measures how long it's been since the highest high or lowest low. When Aroon Down is high and Aroon Up is low, it suggests recent price action has been dominated by lows — a potential reversal setup for a buy. The indicator also prevents signal spam by requiring at least 5 bars between signals of the same type. The TA Scoring System Behind the scenes, the indicator calculates a composite score based on four different technical indicators: MACD — Momentum and trend direction (scores -2 to +2) DMI — Directional movement comparing buyers vs sellers (scores -2 to +2) MFI — Money Flow Index, similar to RSI but incorporates volume (scores -2 to +2) RSI — Classic overbought/oversold measure (scores -1 to +1) These scores are added together, and the result is displayed in the info panel with labels like "very bullish," "slightly bearish," or "neutral." You can optionally require a minimum TA score before signals trigger, adding another layer of confirmation. Visual Display Elements The indicator offers several optional display features: Shaded bands between upper and lower lines Buy/Sell labels directly on the chart showing the entry price Bright blue candle highlighting when a signal fires Info panel in the corner showing the Money Line value, volatility percentile, RSI, and TA score Score dots at the bottom of the chart (green for bullish, red for bearish, yellow for neutral) Debug table for troubleshooting that shows real-time values of Fisher, Aroon, and signal conditions In Summary This indicator is essentially a multi-factor confirmation system. Rather than relying on a single indicator that might give many false signals, it waits until the trend direction (Money Line), momentum extremes (Fisher Transform), price cycle position (Aroon), and overall technical picture (TA Score) all point in the same direction. The adaptive bands help visualize where price "should" be trading given current volatility and trend strength. It's designed for traders who prefer fewer but higher-conviction signals.
Pine Script® indicator
by ralis24
Universal Ratio Trend Matrix [InvestorUnknown]The Universal Ratio Trend Matrix is designed for trend analysis on asset/asset ratios, supporting up to 40 different assets. Its primary purpose is to help identify which assets are outperforming others within a selection, providing a broad overview of market trends through a matrix of ratios. The indicator automatically expands the matrix based on the number of assets chosen, simplifying the process of comparing multiple assets in terms of performance. Key features include the ability to choose from a narrow selection of indicators to perform the ratio trend analysis, allowing users to apply well-defined metrics to their comparison. Drawback: Due to the computational intensity involved in calculating ratios across many assets, the indicator has a limitation related to loading speed. TradingView has time limits for calculations, and for users on the basic (free) plan, this could result in frequent errors due to exceeded time limits. To use the indicator effectively, users with any paid plans should run it on timeframes higher than 8h (the lowest timeframe on which it managed to load with 40 assets), as lower timeframes may not reliably load. Indicators: RSI_raw: Simple function to calculate the Relative Strength Index (RSI) of a source (asset price). RSI_sma: Calculates RSI followed by a Simple Moving Average (SMA). RSI_ema: Calculates RSI followed by an Exponential Moving Average (EMA). CCI: Calculates the Commodity Channel Index (CCI). Fisher: Implements the Fisher Transform to normalize prices. Utility Functions: f_remove_exchange_name: Strips the exchange name from asset tickers (e.g., "INDEX:BTCUSD" to "BTCUSD"). f_remove_exchange_name(simple string name) => string parts = str.split(name, ":") string result = array.size(parts) > 1 ? array.get(parts, 1) : name result f_get_price: Retrieves the closing price of a given asset ticker using request.security(). f_constant_src: Checks if the source data is constant by comparing multiple consecutive values. Inputs: General settings allow users to select the number of tickers for analysis (used_assets) and choose the trend indicator (RSI, CCI, Fisher, etc.). Table settings customize how trend scores are displayed in terms of text size, header visibility, highlighting options, and top-performing asset identification. The script includes inputs for up to 40 assets, allowing the user to select various cryptocurrencies (e.g., BTCUSD, ETHUSD, SOLUSD) or other assets for trend analysis. Price Arrays: Price values for each asset are stored in variables (price_a1 to price_a40) initialized as na. These prices are updated only for the number of assets specified by the user (used_assets). Trend scores for each asset are stored in separate arrays // declare price variables as "na" var float price_a1 = na, var float price_a2 = na, var float price_a3 = na, var float price_a4 = na, var float price_a5 = na var float price_a6 = na, var float price_a7 = na, var float price_a8 = na, var float price_a9 = na, var float price_a10 = na var float price_a11 = na, var float price_a12 = na, var float price_a13 = na, var float price_a14 = na, var float price_a15 = na var float price_a16 = na, var float price_a17 = na, var float price_a18 = na, var float price_a19 = na, var float price_a20 = na var float price_a21 = na, var float price_a22 = na, var float price_a23 = na, var float price_a24 = na, var float price_a25 = na var float price_a26 = na, var float price_a27 = na, var float price_a28 = na, var float price_a29 = na, var float price_a30 = na var float price_a31 = na, var float price_a32 = na, var float price_a33 = na, var float price_a34 = na, var float price_a35 = na var float price_a36 = na, var float price_a37 = na, var float price_a38 = na, var float price_a39 = na, var float price_a40 = na // create "empty" arrays to store trend scores var a1_array = array.new_int(40, 0), var a2_array = array.new_int(40, 0), var a3_array = array.new_int(40, 0), var a4_array = array.new_int(40, 0) var a5_array = array.new_int(40, 0), var a6_array = array.new_int(40, 0), var a7_array = array.new_int(40, 0), var a8_array = array.new_int(40, 0) var a9_array = array.new_int(40, 0), var a10_array = array.new_int(40, 0), var a11_array = array.new_int(40, 0), var a12_array = array.new_int(40, 0) var a13_array = array.new_int(40, 0), var a14_array = array.new_int(40, 0), var a15_array = array.new_int(40, 0), var a16_array = array.new_int(40, 0) var a17_array = array.new_int(40, 0), var a18_array = array.new_int(40, 0), var a19_array = array.new_int(40, 0), var a20_array = array.new_int(40, 0) var a21_array = array.new_int(40, 0), var a22_array = array.new_int(40, 0), var a23_array = array.new_int(40, 0), var a24_array = array.new_int(40, 0) var a25_array = array.new_int(40, 0), var a26_array = array.new_int(40, 0), var a27_array = array.new_int(40, 0), var a28_array = array.new_int(40, 0) var a29_array = array.new_int(40, 0), var a30_array = array.new_int(40, 0), var a31_array = array.new_int(40, 0), var a32_array = array.new_int(40, 0) var a33_array = array.new_int(40, 0), var a34_array = array.new_int(40, 0), var a35_array = array.new_int(40, 0), var a36_array = array.new_int(40, 0) var a37_array = array.new_int(40, 0), var a38_array = array.new_int(40, 0), var a39_array = array.new_int(40, 0), var a40_array = array.new_int(40, 0) f_get_price(simple string ticker) => request.security(ticker, "", close) // Prices for each USED asset f_get_asset_price(asset_number, ticker) => if (used_assets >= asset_number) f_get_price(ticker) else na // overwrite empty variables with the prices if "used_assets" is greater or equal to the asset number if barstate.isconfirmed // use barstate.isconfirmed to avoid "na prices" and calculation errors that result in empty cells in the table price_a1 := f_get_asset_price(1, asset1), price_a2 := f_get_asset_price(2, asset2), price_a3 := f_get_asset_price(3, asset3), price_a4 := f_get_asset_price(4, asset4) price_a5 := f_get_asset_price(5, asset5), price_a6 := f_get_asset_price(6, asset6), price_a7 := f_get_asset_price(7, asset7), price_a8 := f_get_asset_price(8, asset8) price_a9 := f_get_asset_price(9, asset9), price_a10 := f_get_asset_price(10, asset10), price_a11 := f_get_asset_price(11, asset11), price_a12 := f_get_asset_price(12, asset12) price_a13 := f_get_asset_price(13, asset13), price_a14 := f_get_asset_price(14, asset14), price_a15 := f_get_asset_price(15, asset15), price_a16 := f_get_asset_price(16, asset16) price_a17 := f_get_asset_price(17, asset17), price_a18 := f_get_asset_price(18, asset18), price_a19 := f_get_asset_price(19, asset19), price_a20 := f_get_asset_price(20, asset20) price_a21 := f_get_asset_price(21, asset21), price_a22 := f_get_asset_price(22, asset22), price_a23 := f_get_asset_price(23, asset23), price_a24 := f_get_asset_price(24, asset24) price_a25 := f_get_asset_price(25, asset25), price_a26 := f_get_asset_price(26, asset26), price_a27 := f_get_asset_price(27, asset27), price_a28 := f_get_asset_price(28, asset28) price_a29 := f_get_asset_price(29, asset29), price_a30 := f_get_asset_price(30, asset30), price_a31 := f_get_asset_price(31, asset31), price_a32 := f_get_asset_price(32, asset32) price_a33 := f_get_asset_price(33, asset33), price_a34 := f_get_asset_price(34, asset34), price_a35 := f_get_asset_price(35, asset35), price_a36 := f_get_asset_price(36, asset36) price_a37 := f_get_asset_price(37, asset37), price_a38 := f_get_asset_price(38, asset38), price_a39 := f_get_asset_price(39, asset39), price_a40 := f_get_asset_price(40, asset40) Universal Indicator Calculation (f_calc_score): This function allows switching between different trend indicators (RSI, CCI, Fisher) for flexibility. It uses a switch-case structure to calculate the indicator score, where a positive trend is denoted by 1 and a negative trend by 0. Each indicator has its own logic to determine whether the asset is trending up or down. // use switch to allow "universality" in indicator selection f_calc_score(source, trend_indicator, int_1, int_2) => int score = na if (not f_constant_src(source)) and source > 0.0 // Skip if you are using the same assets for ratio (for example BTC/BTC) x = switch trend_indicator "RSI (Raw)" => RSI_raw(source, int_1) "RSI (SMA)" => RSI_sma(source, int_1, int_2) "RSI (EMA)" => RSI_ema(source, int_1, int_2) "CCI" => CCI(source, int_1) "Fisher" => Fisher(source, int_1) y = switch trend_indicator "RSI (Raw)" => x > 50 ? 1 : 0 "RSI (SMA)" => x > 50 ? 1 : 0 "RSI (EMA)" => x > 50 ? 1 : 0 "CCI" => x > 0 ? 1 : 0 "Fisher" => x > x ? 1 : 0 score := y else score := 0 score Array Setting Function (f_array_set): This function populates an array with scores calculated for each asset based on a base price (p_base) divided by the prices of the individual assets. It processes multiple assets (up to 40), calling the f_calc_score function for each. // function to set values into the arrays f_array_set(a_array, p_base) => array.set(a_array, 0, f_calc_score(p_base / price_a1, trend_indicator, int_1, int_2)) array.set(a_array, 1, f_calc_score(p_base / price_a2, trend_indicator, int_1, int_2)) array.set(a_array, 2, f_calc_score(p_base / price_a3, trend_indicator, int_1, int_2)) array.set(a_array, 3, f_calc_score(p_base / price_a4, trend_indicator, int_1, int_2)) array.set(a_array, 4, f_calc_score(p_base / price_a5, trend_indicator, int_1, int_2)) array.set(a_array, 5, f_calc_score(p_base / price_a6, trend_indicator, int_1, int_2)) array.set(a_array, 6, f_calc_score(p_base / price_a7, trend_indicator, int_1, int_2)) array.set(a_array, 7, f_calc_score(p_base / price_a8, trend_indicator, int_1, int_2)) array.set(a_array, 8, f_calc_score(p_base / price_a9, trend_indicator, int_1, int_2)) array.set(a_array, 9, f_calc_score(p_base / price_a10, trend_indicator, int_1, int_2)) array.set(a_array, 10, f_calc_score(p_base / price_a11, trend_indicator, int_1, int_2)) array.set(a_array, 11, f_calc_score(p_base / price_a12, trend_indicator, int_1, int_2)) array.set(a_array, 12, f_calc_score(p_base / price_a13, trend_indicator, int_1, int_2)) array.set(a_array, 13, f_calc_score(p_base / price_a14, trend_indicator, int_1, int_2)) array.set(a_array, 14, f_calc_score(p_base / price_a15, trend_indicator, int_1, int_2)) array.set(a_array, 15, f_calc_score(p_base / price_a16, trend_indicator, int_1, int_2)) array.set(a_array, 16, f_calc_score(p_base / price_a17, trend_indicator, int_1, int_2)) array.set(a_array, 17, f_calc_score(p_base / price_a18, trend_indicator, int_1, int_2)) array.set(a_array, 18, f_calc_score(p_base / price_a19, trend_indicator, int_1, int_2)) array.set(a_array, 19, f_calc_score(p_base / price_a20, trend_indicator, int_1, int_2)) array.set(a_array, 20, f_calc_score(p_base / price_a21, trend_indicator, int_1, int_2)) array.set(a_array, 21, f_calc_score(p_base / price_a22, trend_indicator, int_1, int_2)) array.set(a_array, 22, f_calc_score(p_base / price_a23, trend_indicator, int_1, int_2)) array.set(a_array, 23, f_calc_score(p_base / price_a24, trend_indicator, int_1, int_2)) array.set(a_array, 24, f_calc_score(p_base / price_a25, trend_indicator, int_1, int_2)) array.set(a_array, 25, f_calc_score(p_base / price_a26, trend_indicator, int_1, int_2)) array.set(a_array, 26, f_calc_score(p_base / price_a27, trend_indicator, int_1, int_2)) array.set(a_array, 27, f_calc_score(p_base / price_a28, trend_indicator, int_1, int_2)) array.set(a_array, 28, f_calc_score(p_base / price_a29, trend_indicator, int_1, int_2)) array.set(a_array, 29, f_calc_score(p_base / price_a30, trend_indicator, int_1, int_2)) array.set(a_array, 30, f_calc_score(p_base / price_a31, trend_indicator, int_1, int_2)) array.set(a_array, 31, f_calc_score(p_base / price_a32, trend_indicator, int_1, int_2)) array.set(a_array, 32, f_calc_score(p_base / price_a33, trend_indicator, int_1, int_2)) array.set(a_array, 33, f_calc_score(p_base / price_a34, trend_indicator, int_1, int_2)) array.set(a_array, 34, f_calc_score(p_base / price_a35, trend_indicator, int_1, int_2)) array.set(a_array, 35, f_calc_score(p_base / price_a36, trend_indicator, int_1, int_2)) array.set(a_array, 36, f_calc_score(p_base / price_a37, trend_indicator, int_1, int_2)) array.set(a_array, 37, f_calc_score(p_base / price_a38, trend_indicator, int_1, int_2)) array.set(a_array, 38, f_calc_score(p_base / price_a39, trend_indicator, int_1, int_2)) array.set(a_array, 39, f_calc_score(p_base / price_a40, trend_indicator, int_1, int_2)) a_array Conditional Array Setting (f_arrayset): This function checks if the number of used assets is greater than or equal to a specified number before populating the arrays. // only set values into arrays for USED assets f_arrayset(asset_number, a_array, p_base) => if (used_assets >= asset_number) f_array_set(a_array, p_base) else na Main Logic The main logic initializes arrays to store scores for each asset. Each array corresponds to one asset's performance score. Setting Trend Values: The code calls f_arrayset for each asset, populating the respective arrays with calculated scores based on the asset prices. Combining Arrays: A combined_array is created to hold all the scores from individual asset arrays. This array facilitates further analysis, allowing for an overview of the performance scores of all assets at once. // create a combined array (work-around since pinescript doesn't support having array of arrays) var combined_array = array.new_int(40 * 40, 0) if barstate.islast for i = 0 to 39 array.set(combined_array, i, array.get(a1_array, i)) array.set(combined_array, i + (40 * 1), array.get(a2_array, i)) array.set(combined_array, i + (40 * 2), array.get(a3_array, i)) array.set(combined_array, i + (40 * 3), array.get(a4_array, i)) array.set(combined_array, i + (40 * 4), array.get(a5_array, i)) array.set(combined_array, i + (40 * 5), array.get(a6_array, i)) array.set(combined_array, i + (40 * 6), array.get(a7_array, i)) array.set(combined_array, i + (40 * 7), array.get(a8_array, i)) array.set(combined_array, i + (40 * 8), array.get(a9_array, i)) array.set(combined_array, i + (40 * 9), array.get(a10_array, i)) array.set(combined_array, i + (40 * 10), array.get(a11_array, i)) array.set(combined_array, i + (40 * 11), array.get(a12_array, i)) array.set(combined_array, i + (40 * 12), array.get(a13_array, i)) array.set(combined_array, i + (40 * 13), array.get(a14_array, i)) array.set(combined_array, i + (40 * 14), array.get(a15_array, i)) array.set(combined_array, i + (40 * 15), array.get(a16_array, i)) array.set(combined_array, i + (40 * 16), array.get(a17_array, i)) array.set(combined_array, i + (40 * 17), array.get(a18_array, i)) array.set(combined_array, i + (40 * 18), array.get(a19_array, i)) array.set(combined_array, i + (40 * 19), array.get(a20_array, i)) array.set(combined_array, i + (40 * 20), array.get(a21_array, i)) array.set(combined_array, i + (40 * 21), array.get(a22_array, i)) array.set(combined_array, i + (40 * 22), array.get(a23_array, i)) array.set(combined_array, i + (40 * 23), array.get(a24_array, i)) array.set(combined_array, i + (40 * 24), array.get(a25_array, i)) array.set(combined_array, i + (40 * 25), array.get(a26_array, i)) array.set(combined_array, i + (40 * 26), array.get(a27_array, i)) array.set(combined_array, i + (40 * 27), array.get(a28_array, i)) array.set(combined_array, i + (40 * 28), array.get(a29_array, i)) array.set(combined_array, i + (40 * 29), array.get(a30_array, i)) array.set(combined_array, i + (40 * 30), array.get(a31_array, i)) array.set(combined_array, i + (40 * 31), array.get(a32_array, i)) array.set(combined_array, i + (40 * 32), array.get(a33_array, i)) array.set(combined_array, i + (40 * 33), array.get(a34_array, i)) array.set(combined_array, i + (40 * 34), array.get(a35_array, i)) array.set(combined_array, i + (40 * 35), array.get(a36_array, i)) array.set(combined_array, i + (40 * 36), array.get(a37_array, i)) array.set(combined_array, i + (40 * 37), array.get(a38_array, i)) array.set(combined_array, i + (40 * 38), array.get(a39_array, i)) array.set(combined_array, i + (40 * 39), array.get(a40_array, i)) Calculating Sums: A separate array_sums is created to store the total score for each asset by summing the values of their respective score arrays. This allows for easy comparison of overall performance. Ranking Assets: The final part of the code ranks the assets based on their total scores stored in array_sums. It assigns a rank to each asset, where the asset with the highest score receives the highest rank. // create array for asset RANK based on array.sum var ranks = array.new_int(used_assets, 0) // for loop that calculates the rank of each asset if barstate.islast for i = 0 to (used_assets - 1) int rank = 1 for x = 0 to (used_assets - 1) if i != x if array.get(array_sums, i) < array.get(array_sums, x) rank := rank + 1 array.set(ranks, i, rank) Dynamic Table Creation Initialization: The table is initialized with a base structure that includes headers for asset names, scores, and ranks. The headers are set to remain constant, ensuring clarity for users as they interpret the displayed data. Data Population: As scores are calculated for each asset, the corresponding values are dynamically inserted into the table. This is achieved through a loop that iterates over the scores and ranks stored in the combined_array and array_sums, respectively. Automatic Extending Mechanism Variable Asset Count: The code checks the number of assets defined by the user. Instead of hardcoding the number of rows in the table, it uses a variable to determine the extent of the data that needs to be displayed. This allows the table to expand or contract based on the number of assets being analyzed. Dynamic Row Generation: Within the loop that populates the table, the code appends new rows for each asset based on the current asset count. The structure of each row includes the asset name, its score, and its rank, ensuring that the table remains consistent regardless of how many assets are involved. // Automatically extending table based on the number of used assets var table table = table.new(position.bottom_center, 50, 50, color.new(color.black, 100), color.white, 3, color.white, 1) if barstate.islast if not hide_head table.cell(table, 0, 0, "Universal Ratio Trend Matrix", text_color = color.white, bgcolor = #010c3b, text_size = fontSize) table.merge_cells(table, 0, 0, used_assets + 3, 0) if not hide_inps table.cell(table, 0, 1, text = "Inputs: You are using " + str.tostring(trend_indicator) + ", which takes: " + str.tostring(f_get_input(trend_indicator)), text_color = color.white, text_size = fontSize), table.merge_cells(table, 0, 1, used_assets + 3, 1) table.cell(table, 0, 2, "Assets", text_color = color.white, text_size = fontSize, bgcolor = #010c3b) for x = 0 to (used_assets - 1) table.cell(table, x + 1, 2, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = #010c3b, text_size = fontSize) table.cell(table, 0, x + 3, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = f_asset_col(array.get(ranks, x)), text_size = fontSize) for r = 0 to (used_assets - 1) for c = 0 to (used_assets - 1) table.cell(table, c + 1, r + 3, text = str.tostring(array.get(combined_array, c + (r * 40))), text_color = hl_type == "Text" ? f_get_col(array.get(combined_array, c + (r * 40))) : color.white, text_size = fontSize, bgcolor = hl_type == "Background" ? f_get_col(array.get(combined_array, c + (r * 40))) : na) for x = 0 to (used_assets - 1) table.cell(table, x + 1, x + 3, "", bgcolor = #010c3b) table.cell(table, used_assets + 1, 2, "", bgcolor = #010c3b) for x = 0 to (used_assets - 1) table.cell(table, used_assets + 1, x + 3, "==>", text_color = color.white) table.cell(table, used_assets + 2, 2, "SUM", text_color = color.white, text_size = fontSize, bgcolor = #010c3b) table.cell(table, used_assets + 3, 2, "RANK", text_color = color.white, text_size = fontSize, bgcolor = #010c3b) for x = 0 to (used_assets - 1) table.cell(table, used_assets + 2, x + 3, text = str.tostring(array.get(array_sums, x)), text_color = color.white, text_size = fontSize, bgcolor = f_highlight_sum(array.get(array_sums, x), array.get(ranks, x))) table.cell(table, used_assets + 3, x + 3, text = str.tostring(array.get(ranks, x)), text_color = color.white, text_size = fontSize, bgcolor = f_highlight_rank(array.get(ranks, x)))
Pine Script® indicator
by InvestorUnknown
8
Markov Chain [3D] | FractalystWhat exactly is a Markov Chain? This indicator uses a Markov Chain model to analyze, quantify, and visualize the transitions between market regimes (Bull, Bear, Neutral) on your chart. It dynamically detects these regimes in real-time, calculates transition probabilities, and displays them as animated 3D spheres and arrows, giving traders intuitive insight into current and future market conditions. How does a Markov Chain work, and how should I read this spheres-and-arrows diagram? Think of three weather modes: Sunny, Rainy, Cloudy. Each sphere is one mode. The loop on a sphere means “stay the same next step” (e.g., Sunny again tomorrow). The arrows leaving a sphere show where things usually go next if they change (e.g., Sunny moving to Cloudy). Some paths matter more than others. A more prominent loop means the current mode tends to persist. A more prominent outgoing arrow means a change to that destination is the usual next step. Direction isn’t symmetric: moving Sunny→Cloudy can behave differently than Cloudy→Sunny. Now relabel the spheres to markets: Bull, Bear, Neutral. Spheres: market regimes (uptrend, downtrend, range). Self‑loop: tendency for the current regime to continue on the next bar. Arrows: the most common next regime if a switch happens. How to read: Start at the sphere that matches current bar state. If the loop stands out, expect continuation. If one outgoing path stands out, that switch is the typical next step. Opposite directions can differ (Bear→Neutral doesn’t have to match Neutral→Bear). What states and transitions are shown? The three market states visualized are: Bullish (Bull): Upward or strong-market regime. Bearish (Bear): Downward or weak-market regime. Neutral: Sideways or range-bound regime. Bidirectional animated arrows and probability labels show how likely the market is to move from one regime to another (e.g., Bull → Bear or Neutral → Bull). How does the regime detection system work? You can use either built-in price returns (based on adaptive Z-score normalization) or supply three custom indicators (such as volume, oscillators, etc.). Values are statistically normalized (Z-scored) over a configurable lookback period. The normalized outputs are classified into Bull, Bear, or Neutral zones. If using three indicators, their regime signals are averaged and smoothed for robustness. How are transition probabilities calculated? On every confirmed bar, the algorithm tracks the sequence of detected market states, then builds a rolling window of transitions. The code maintains a transition count matrix for all regime pairs (e.g., Bull → Bear). Transition probabilities are extracted for each possible state change using Laplace smoothing for numerical stability, and frequently updated in real-time. What is unique about the visualization? 3D animated spheres represent each regime and change visually when active. Animated, bidirectional arrows reveal transition probabilities and allow you to see both dominant and less likely regime flows. Particles (moving dots) animate along the arrows, enhancing the perception of regime flow direction and speed. All elements dynamically update with each new price bar, providing a live market map in an intuitive, engaging format. Can I use custom indicators for regime classification? Yes! Enable the "Custom Indicators" switch and select any three chart series as inputs. These will be normalized and combined (each with equal weight), broadening the regime classification beyond just price-based movement. What does the “Lookback Period” control? Lookback Period (default: 100) sets how much historical data builds the probability matrix. Shorter periods adapt faster to regime changes but may be noisier. Longer periods are more stable but slower to adapt. How is this different from a Hidden Markov Model (HMM)? It sets the window for both regime detection and probability calculations. Lower values make the system more reactive, but potentially noisier. Higher values smooth estimates and make the system more robust. How is this Markov Chain different from a Hidden Markov Model (HMM)? Markov Chain (as here): All market regimes (Bull, Bear, Neutral) are directly observable on the chart. The transition matrix is built from actual detected regimes, keeping the model simple and interpretable. Hidden Markov Model: The actual regimes are unobservable ("hidden") and must be inferred from market output or indicator "emissions" using statistical learning algorithms. HMMs are more complex, can capture more subtle structure, but are harder to visualize and require additional machine learning steps for training. A standard Markov Chain models transitions between observable states using a simple transition matrix, while a Hidden Markov Model assumes the true states are hidden (latent) and must be inferred from observable “emissions” like price or volume data. In practical terms, a Markov Chain is transparent and easier to implement and interpret; an HMM is more expressive but requires statistical inference to estimate hidden states from data. Markov Chain: states are observable; you directly count or estimate transition probabilities between visible states. This makes it simpler, faster, and easier to validate and tune. HMM: states are hidden; you only observe emissions generated by those latent states. Learning involves machine learning/statistical algorithms (commonly Baum–Welch/EM for training and Viterbi for decoding) to infer both the transition dynamics and the most likely hidden state sequence from data. How does the indicator avoid “repainting” or look-ahead bias? All regime changes and matrix updates happen only on confirmed (closed) bars, so no future data is leaked, ensuring reliable real-time operation. Are there practical tuning tips? Tune the Lookback Period for your asset/timeframe: shorter for fast markets, longer for stability. Use custom indicators if your asset has unique regime drivers. Watch for rapid changes in transition probabilities as early warning of a possible regime shift. Who is this indicator for? Quants and quantitative researchers exploring probabilistic market modeling, especially those interested in regime-switching dynamics and Markov models. Programmers and system developers who need a probabilistic regime filter for systematic and algorithmic backtesting: The Markov Chain indicator is ideally suited for programmatic integration via its bias output (1 = Bull, 0 = Neutral, -1 = Bear). Although the visualization is engaging, the core output is designed for automated, rules-based workflows—not for discretionary/manual trading decisions. Developers can connect the indicator’s output directly to their Pine Script logic (using input.source()), allowing rapid and robust backtesting of regime-based strategies. It acts as a plug-and-play regime filter: simply plug the bias output into your entry/exit logic, and you have a scientifically robust, probabilistically-derived signal for filtering, timing, position sizing, or risk regimes. The MC's output is intentionally "trinary" (1/0/-1), focusing on clear regime states for unambiguous decision-making in code. If you require nuanced, multi-probability or soft-label state vectors, consider expanding the indicator or stacking it with a probability-weighted logic layer in your scripting. Because it avoids subjectivity, this approach is optimal for systematic quants, algo developers building backtested, repeatable strategies based on probabilistic regime analysis. What's the mathematical foundation behind this? The mathematical foundation behind this Markov Chain indicator—and probabilistic regime detection in finance—draws from two principal models: the (standard) Markov Chain and the Hidden Markov Model (HMM). How to use this indicator programmatically? The Markov Chain indicator automatically exports a bias value (+1 for Bullish, -1 for Bearish, 0 for Neutral) as a plot visible in the Data Window. This allows you to integrate its regime signal into your own scripts and strategies for backtesting, automation, or live trading. Step-by-Step Integration with Pine Script (input.source) Add the Markov Chain indicator to your chart. This must be done first, since your custom script will "pull" the bias signal from the indicator's plot. In your strategy, create an input using input.source() Example: //@version=5 strategy("MC Bias Strategy Example") mcBias = input.source(close, "MC Bias Source") After saving, go to your script’s settings. For the “MC Bias Source” input, select the plot/output of the Markov Chain indicator (typically its bias plot). Use the bias in your trading logic Example (long only on Bull, flat otherwise): if mcBias == 1 strategy.entry("Long", strategy.long) else strategy.close("Long") For more advanced workflows, combine mcBias with additional filters or trailing stops. How does this work behind-the-scenes? TradingView’s input.source() lets you use any plot from another indicator as a real-time, “live” data feed in your own script (source). The selected bias signal is available to your Pine code as a variable, enabling logical decisions based on regime (trend-following, mean-reversion, etc.). This enables powerful strategy modularity : decouple regime detection from entry/exit logic, allowing fast experimentation without rewriting core signal code. Integrating 45+ Indicators with Your Markov Chain — How & Why The Enhanced Custom Indicators Export script exports a massive suite of over 45 technical indicators—ranging from classic momentum (RSI, MACD, Stochastic, etc.) to trend, volume, volatility, and oscillator tools—all pre-calculated, centered/scaled, and available as plots. // Enhanced Custom Indicators Export - 45 Technical Indicators // Comprehensive technical analysis suite for advanced market regime detection //@version=6 indicator('Enhanced Custom Indicators Export | Fractalyst', shorttitle='Enhanced CI Export', overlay=false, scale=scale.right, max_labels_count=500, max_lines_count=500) // |----- Input Parameters -----| // momentum_group = "Momentum Indicators" trend_group = "Trend Indicators" volume_group = "Volume Indicators" volatility_group = "Volatility Indicators" oscillator_group = "Oscillator Indicators" display_group = "Display Settings" // Common lengths length_14 = input.int(14, "Standard Length (14)", minval=1, maxval=100, group=momentum_group) length_20 = input.int(20, "Medium Length (20)", minval=1, maxval=200, group=trend_group) length_50 = input.int(50, "Long Length (50)", minval=1, maxval=200, group=trend_group) // Display options show_table = input.bool(true, "Show Values Table", group=display_group) table_size = input.string("Small", "Table Size", options= , group=display_group) // |----- MOMENTUM INDICATORS (15 indicators) -----| // // 1. RSI (Relative Strength Index) rsi_14 = ta.rsi(close, length_14) rsi_centered = rsi_14 - 50 // 2. Stochastic Oscillator stoch_k = ta.stoch(close, high, low, length_14) stoch_d = ta.sma(stoch_k, 3) stoch_centered = stoch_k - 50 // 3. Williams %R williams_r = ta.stoch(close, high, low, length_14) - 100 // 4. MACD (Moving Average Convergence Divergence) = ta.macd(close, 12, 26, 9) // 5. Momentum (Rate of Change) momentum = ta.mom(close, length_14) momentum_pct = (momentum / close ) * 100 // 6. Rate of Change (ROC) roc = ta.roc(close, length_14) // 7. Commodity Channel Index (CCI) cci = ta.cci(close, length_20) // 8. Money Flow Index (MFI) mfi = ta.mfi(close, length_14) mfi_centered = mfi - 50 // 9. Awesome Oscillator (AO) ao = ta.sma(hl2, 5) - ta.sma(hl2, 34) // 10. Accelerator Oscillator (AC) ac = ao - ta.sma(ao, 5) // 11. Chande Momentum Oscillator (CMO) cmo = ta.cmo(close, length_14) // 12. Detrended Price Oscillator (DPO) dpo = close - ta.sma(close, length_20) // 13. Price Oscillator (PPO) ppo = ta.sma(close, 12) - ta.sma(close, 26) ppo_pct = (ppo / ta.sma(close, 26)) * 100 // 14. TRIX trix_ema1 = ta.ema(close, length_14) trix_ema2 = ta.ema(trix_ema1, length_14) trix_ema3 = ta.ema(trix_ema2, length_14) trix = ta.roc(trix_ema3, 1) * 10000 // 15. Klinger Oscillator klinger = ta.ema(volume * (high + low + close) / 3, 34) - ta.ema(volume * (high + low + close) / 3, 55) // 16. Fisher Transform fisher_hl2 = 0.5 * (hl2 - ta.lowest(hl2, 10)) / (ta.highest(hl2, 10) - ta.lowest(hl2, 10)) - 0.25 fisher = 0.5 * math.log((1 + fisher_hl2) / (1 - fisher_hl2)) // 17. Stochastic RSI stoch_rsi = ta.stoch(rsi_14, rsi_14, rsi_14, length_14) stoch_rsi_centered = stoch_rsi - 50 // 18. Relative Vigor Index (RVI) rvi_num = ta.swma(close - open) rvi_den = ta.swma(high - low) rvi = rvi_den != 0 ? rvi_num / rvi_den : 0 // 19. Balance of Power (BOP) bop = (close - open) / (high - low) // |----- TREND INDICATORS (10 indicators) -----| // // 20. Simple Moving Average Momentum sma_20 = ta.sma(close, length_20) sma_momentum = ((close - sma_20) / sma_20) * 100 // 21. Exponential Moving Average Momentum ema_20 = ta.ema(close, length_20) ema_momentum = ((close - ema_20) / ema_20) * 100 // 22. Parabolic SAR sar = ta.sar(0.02, 0.02, 0.2) sar_trend = close > sar ? 1 : -1 // 23. Linear Regression Slope lr_slope = ta.linreg(close, length_20, 0) - ta.linreg(close, length_20, 1) // 24. Moving Average Convergence (MAC) mac = ta.sma(close, 10) - ta.sma(close, 30) // 25. Trend Intensity Index (TII) tii_sum = 0.0 for i = 1 to length_20 tii_sum += close > close ? 1 : 0 tii = (tii_sum / length_20) * 100 // 26. Ichimoku Cloud Components ichimoku_tenkan = (ta.highest(high, 9) + ta.lowest(low, 9)) / 2 ichimoku_kijun = (ta.highest(high, 26) + ta.lowest(low, 26)) / 2 ichimoku_signal = ichimoku_tenkan > ichimoku_kijun ? 1 : -1 // 27. MESA Adaptive Moving Average (MAMA) mama_alpha = 2.0 / (length_20 + 1) mama = ta.ema(close, length_20) mama_momentum = ((close - mama) / mama) * 100 // 28. Zero Lag Exponential Moving Average (ZLEMA) zlema_lag = math.round((length_20 - 1) / 2) zlema_data = close + (close - close ) zlema = ta.ema(zlema_data, length_20) zlema_momentum = ((close - zlema) / zlema) * 100 // |----- VOLUME INDICATORS (6 indicators) -----| // // 29. On-Balance Volume (OBV) obv = ta.obv // 30. Volume Rate of Change (VROC) vroc = ta.roc(volume, length_14) // 31. Price Volume Trend (PVT) pvt = ta.pvt // 32. Negative Volume Index (NVI) nvi = 0.0 nvi := volume < volume ? nvi + ((close - close ) / close ) * nvi : nvi // 33. Positive Volume Index (PVI) pvi = 0.0 pvi := volume > volume ? pvi + ((close - close ) / close ) * pvi : pvi // 34. Volume Oscillator vol_osc = ta.sma(volume, 5) - ta.sma(volume, 10) // 35. Ease of Movement (EOM) eom_distance = high - low eom_box_height = volume / 1000000 eom = eom_box_height != 0 ? eom_distance / eom_box_height : 0 eom_sma = ta.sma(eom, length_14) // 36. Force Index force_index = volume * (close - close ) force_index_sma = ta.sma(force_index, length_14) // |----- VOLATILITY INDICATORS (10 indicators) -----| // // 37. Average True Range (ATR) atr = ta.atr(length_14) atr_pct = (atr / close) * 100 // 38. Bollinger Bands Position bb_basis = ta.sma(close, length_20) bb_dev = 2.0 * ta.stdev(close, length_20) bb_upper = bb_basis + bb_dev bb_lower = bb_basis - bb_dev bb_position = bb_dev != 0 ? (close - bb_basis) / bb_dev : 0 bb_width = bb_dev != 0 ? (bb_upper - bb_lower) / bb_basis * 100 : 0 // 39. Keltner Channels Position kc_basis = ta.ema(close, length_20) kc_range = ta.ema(ta.tr, length_20) kc_upper = kc_basis + (2.0 * kc_range) kc_lower = kc_basis - (2.0 * kc_range) kc_position = kc_range != 0 ? (close - kc_basis) / kc_range : 0 // 40. Donchian Channels Position dc_upper = ta.highest(high, length_20) dc_lower = ta.lowest(low, length_20) dc_basis = (dc_upper + dc_lower) / 2 dc_position = (dc_upper - dc_lower) != 0 ? (close - dc_basis) / (dc_upper - dc_lower) : 0 // 41. Standard Deviation std_dev = ta.stdev(close, length_20) std_dev_pct = (std_dev / close) * 100 // 42. Relative Volatility Index (RVI) rvi_up = ta.stdev(close > close ? close : 0, length_14) rvi_down = ta.stdev(close < close ? close : 0, length_14) rvi_total = rvi_up + rvi_down rvi_volatility = rvi_total != 0 ? (rvi_up / rvi_total) * 100 : 50 // 43. Historical Volatility hv_returns = math.log(close / close ) hv = ta.stdev(hv_returns, length_20) * math.sqrt(252) * 100 // 44. Garman-Klass Volatility gk_vol = math.log(high/low) * math.log(high/low) - (2*math.log(2)-1) * math.log(close/open) * math.log(close/open) gk_volatility = math.sqrt(ta.sma(gk_vol, length_20)) * 100 // 45. Parkinson Volatility park_vol = math.log(high/low) * math.log(high/low) parkinson = math.sqrt(ta.sma(park_vol, length_20) / (4 * math.log(2))) * 100 // 46. Rogers-Satchell Volatility rs_vol = math.log(high/close) * math.log(high/open) + math.log(low/close) * math.log(low/open) rogers_satchell = math.sqrt(ta.sma(rs_vol, length_20)) * 100 // |----- OSCILLATOR INDICATORS (5 indicators) -----| // // 47. Elder Ray Index elder_bull = high - ta.ema(close, 13) elder_bear = low - ta.ema(close, 13) elder_power = elder_bull + elder_bear // 48. Schaff Trend Cycle (STC) stc_macd = ta.ema(close, 23) - ta.ema(close, 50) stc_k = ta.stoch(stc_macd, stc_macd, stc_macd, 10) stc_d = ta.ema(stc_k, 3) stc = ta.stoch(stc_d, stc_d, stc_d, 10) // 49. Coppock Curve coppock_roc1 = ta.roc(close, 14) coppock_roc2 = ta.roc(close, 11) coppock = ta.wma(coppock_roc1 + coppock_roc2, 10) // 50. Know Sure Thing (KST) kst_roc1 = ta.roc(close, 10) kst_roc2 = ta.roc(close, 15) kst_roc3 = ta.roc(close, 20) kst_roc4 = ta.roc(close, 30) kst = ta.sma(kst_roc1, 10) + 2*ta.sma(kst_roc2, 10) + 3*ta.sma(kst_roc3, 10) + 4*ta.sma(kst_roc4, 15) // 51. Percentage Price Oscillator (PPO) ppo_line = ((ta.ema(close, 12) - ta.ema(close, 26)) / ta.ema(close, 26)) * 100 ppo_signal = ta.ema(ppo_line, 9) ppo_histogram = ppo_line - ppo_signal // |----- PLOT MAIN INDICATORS -----| // // Plot key momentum indicators plot(rsi_centered, title="01_RSI_Centered", color=color.purple, linewidth=1) plot(stoch_centered, title="02_Stoch_Centered", color=color.blue, linewidth=1) plot(williams_r, title="03_Williams_R", color=color.red, linewidth=1) plot(macd_histogram, title="04_MACD_Histogram", color=color.orange, linewidth=1) plot(cci, title="05_CCI", color=color.green, linewidth=1) // Plot trend indicators plot(sma_momentum, title="06_SMA_Momentum", color=color.navy, linewidth=1) plot(ema_momentum, title="07_EMA_Momentum", color=color.maroon, linewidth=1) plot(sar_trend, title="08_SAR_Trend", color=color.teal, linewidth=1) plot(lr_slope, title="09_LR_Slope", color=color.lime, linewidth=1) plot(mac, title="10_MAC", color=color.fuchsia, linewidth=1) // Plot volatility indicators plot(atr_pct, title="11_ATR_Pct", color=color.yellow, linewidth=1) plot(bb_position, title="12_BB_Position", color=color.aqua, linewidth=1) plot(kc_position, title="13_KC_Position", color=color.olive, linewidth=1) plot(std_dev_pct, title="14_StdDev_Pct", color=color.silver, linewidth=1) plot(bb_width, title="15_BB_Width", color=color.gray, linewidth=1) // Plot volume indicators plot(vroc, title="16_VROC", color=color.blue, linewidth=1) plot(eom_sma, title="17_EOM", color=color.red, linewidth=1) plot(vol_osc, title="18_Vol_Osc", color=color.green, linewidth=1) plot(force_index_sma, title="19_Force_Index", color=color.orange, linewidth=1) plot(obv, title="20_OBV", color=color.purple, linewidth=1) // Plot additional oscillators plot(ao, title="21_Awesome_Osc", color=color.navy, linewidth=1) plot(cmo, title="22_CMO", color=color.maroon, linewidth=1) plot(dpo, title="23_DPO", color=color.teal, linewidth=1) plot(trix, title="24_TRIX", color=color.lime, linewidth=1) plot(fisher, title="25_Fisher", color=color.fuchsia, linewidth=1) // Plot more momentum indicators plot(mfi_centered, title="26_MFI_Centered", color=color.yellow, linewidth=1) plot(ac, title="27_AC", color=color.aqua, linewidth=1) plot(ppo_pct, title="28_PPO_Pct", color=color.olive, linewidth=1) plot(stoch_rsi_centered, title="29_StochRSI_Centered", color=color.silver, linewidth=1) plot(klinger, title="30_Klinger", color=color.gray, linewidth=1) // Plot trend continuation plot(tii, title="31_TII", color=color.blue, linewidth=1) plot(ichimoku_signal, title="32_Ichimoku_Signal", color=color.red, linewidth=1) plot(mama_momentum, title="33_MAMA_Momentum", color=color.green, linewidth=1) plot(zlema_momentum, title="34_ZLEMA_Momentum", color=color.orange, linewidth=1) plot(bop, title="35_BOP", color=color.purple, linewidth=1) // Plot volume continuation plot(nvi, title="36_NVI", color=color.navy, linewidth=1) plot(pvi, title="37_PVI", color=color.maroon, linewidth=1) plot(momentum_pct, title="38_Momentum_Pct", color=color.teal, linewidth=1) plot(roc, title="39_ROC", color=color.lime, linewidth=1) plot(rvi, title="40_RVI", color=color.fuchsia, linewidth=1) // Plot volatility continuation plot(dc_position, title="41_DC_Position", color=color.yellow, linewidth=1) plot(rvi_volatility, title="42_RVI_Volatility", color=color.aqua, linewidth=1) plot(hv, title="43_Historical_Vol", color=color.olive, linewidth=1) plot(gk_volatility, title="44_GK_Volatility", color=color.silver, linewidth=1) plot(parkinson, title="45_Parkinson_Vol", color=color.gray, linewidth=1) // Plot final oscillators plot(rogers_satchell, title="46_RS_Volatility", color=color.blue, linewidth=1) plot(elder_power, title="47_Elder_Power", color=color.red, linewidth=1) plot(stc, title="48_STC", color=color.green, linewidth=1) plot(coppock, title="49_Coppock", color=color.orange, linewidth=1) plot(kst, title="50_KST", color=color.purple, linewidth=1) // Plot final indicators plot(ppo_histogram, title="51_PPO_Histogram", color=color.navy, linewidth=1) plot(pvt, title="52_PVT", color=color.maroon, linewidth=1) // |----- Reference Lines -----| // hline(0, "Zero Line", color=color.gray, linestyle=hline.style_dashed, linewidth=1) hline(50, "Midline", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(-50, "Lower Midline", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(25, "Upper Threshold", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(-25, "Lower Threshold", color=color.gray, linestyle=hline.style_dotted, linewidth=1) // |----- Enhanced Information Table -----| // if show_table and barstate.islast table_position = position.top_right table_text_size = table_size == "Tiny" ? size.tiny : table_size == "Small" ? size.small : size.normal var table info_table = table.new(table_position, 3, 18, bgcolor=color.new(color.white, 85), border_width=1, border_color=color.gray) // Headers table.cell(info_table, 0, 0, 'Category', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) table.cell(info_table, 1, 0, 'Indicator', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) table.cell(info_table, 2, 0, 'Value', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) // Key Momentum Indicators table.cell(info_table, 0, 1, 'MOMENTUM', text_color=color.purple, text_size=table_text_size, bgcolor=color.new(color.purple, 90)) table.cell(info_table, 1, 1, 'RSI Centered', text_color=color.purple, text_size=table_text_size) table.cell(info_table, 2, 1, str.tostring(rsi_centered, '0.00'), text_color=color.purple, text_size=table_text_size) table.cell(info_table, 0, 2, '', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 1, 2, 'Stoch Centered', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 2, str.tostring(stoch_centered, '0.00'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 3, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 3, 'Williams %R', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 3, str.tostring(williams_r, '0.00'), text_color=color.red, text_size=table_text_size) table.cell(info_table, 0, 4, '', text_color=color.orange, text_size=table_text_size) table.cell(info_table, 1, 4, 'MACD Histogram', text_color=color.orange, text_size=table_text_size) table.cell(info_table, 2, 4, str.tostring(macd_histogram, '0.000'), text_color=color.orange, text_size=table_text_size) table.cell(info_table, 0, 5, '', text_color=color.green, text_size=table_text_size) table.cell(info_table, 1, 5, 'CCI', text_color=color.green, text_size=table_text_size) table.cell(info_table, 2, 5, str.tostring(cci, '0.00'), text_color=color.green, text_size=table_text_size) // Key Trend Indicators table.cell(info_table, 0, 6, 'TREND', text_color=color.navy, text_size=table_text_size, bgcolor=color.new(color.navy, 90)) table.cell(info_table, 1, 6, 'SMA Momentum %', text_color=color.navy, text_size=table_text_size) table.cell(info_table, 2, 6, str.tostring(sma_momentum, '0.00'), text_color=color.navy, text_size=table_text_size) table.cell(info_table, 0, 7, '', text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 1, 7, 'EMA Momentum %', text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 2, 7, str.tostring(ema_momentum, '0.00'), text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 0, 8, '', text_color=color.teal, text_size=table_text_size) table.cell(info_table, 1, 8, 'SAR Trend', text_color=color.teal, text_size=table_text_size) table.cell(info_table, 2, 8, str.tostring(sar_trend, '0'), text_color=color.teal, text_size=table_text_size) table.cell(info_table, 0, 9, '', text_color=color.lime, text_size=table_text_size) table.cell(info_table, 1, 9, 'Linear Regression', text_color=color.lime, text_size=table_text_size) table.cell(info_table, 2, 9, str.tostring(lr_slope, '0.000'), text_color=color.lime, text_size=table_text_size) // Key Volatility Indicators table.cell(info_table, 0, 10, 'VOLATILITY', text_color=color.yellow, text_size=table_text_size, bgcolor=color.new(color.yellow, 90)) table.cell(info_table, 1, 10, 'ATR %', text_color=color.yellow, text_size=table_text_size) table.cell(info_table, 2, 10, str.tostring(atr_pct, '0.00'), text_color=color.yellow, text_size=table_text_size) table.cell(info_table, 0, 11, '', text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 1, 11, 'BB Position', text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 2, 11, str.tostring(bb_position, '0.00'), text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 0, 12, '', text_color=color.olive, text_size=table_text_size) table.cell(info_table, 1, 12, 'KC Position', text_color=color.olive, text_size=table_text_size) table.cell(info_table, 2, 12, str.tostring(kc_position, '0.00'), text_color=color.olive, text_size=table_text_size) // Key Volume Indicators table.cell(info_table, 0, 13, 'VOLUME', text_color=color.blue, text_size=table_text_size, bgcolor=color.new(color.blue, 90)) table.cell(info_table, 1, 13, 'Volume ROC', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 13, str.tostring(vroc, '0.00'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 14, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 14, 'EOM', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 14, str.tostring(eom_sma, '0.000'), text_color=color.red, text_size=table_text_size) // Key Oscillators table.cell(info_table, 0, 15, 'OSCILLATORS', text_color=color.purple, text_size=table_text_size, bgcolor=color.new(color.purple, 90)) table.cell(info_table, 1, 15, 'Awesome Osc', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 15, str.tostring(ao, '0.000'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 16, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 16, 'Fisher Transform', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 16, str.tostring(fisher, '0.000'), text_color=color.red, text_size=table_text_size) // Summary Statistics table.cell(info_table, 0, 17, 'SUMMARY', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.gray, 70)) table.cell(info_table, 1, 17, 'Total Indicators: 52', text_color=color.black, text_size=table_text_size) regime_color = rsi_centered > 10 ? color.green : rsi_centered < -10 ? color.red : color.gray regime_text = rsi_centered > 10 ? "BULLISH" : rsi_centered < -10 ? "BEARISH" : "NEUTRAL" table.cell(info_table, 2, 17, regime_text, text_color=regime_color, text_size=table_text_size) This makes it the perfect “indicator backbone” for quantitative and systematic traders who want to prototype, combine, and test new regime detection models—especially in combination with the Markov Chain indicator. How to use this script with the Markov Chain for research and backtesting: Add the Enhanced Indicator Export to your chart. Every calculated indicator is available as an individual data stream. Connect the indicator(s) you want as custom input(s) to the Markov Chain’s “Custom Indicators” option. In the Markov Chain indicator’s settings, turn ON the custom indicator mode. For each of the three custom indicator inputs, select the exported plot from the Enhanced Export script—the menu lists all 45+ signals by name. This creates a powerful, modular regime-detection engine where you can mix-and-match momentum, trend, volume, or custom combinations for advanced filtering. Backtest regime logic directly. Once you’ve connected your chosen indicators, the Markov Chain script performs regime detection (Bull/Neutral/Bear) based on your selected features—not just price returns. The regime detection is robust, automatically normalized (using Z-score), and outputs bias (1, -1, 0) for plug-and-play integration. Export the regime bias for programmatic use. As described above, use input.source() in your Pine Script strategy or system and link the bias output. You can now filter signals, control trade direction/size, or design pairs-trading that respect true, indicator-driven market regimes. With this framework, you’re not limited to static or simplistic regime filters. You can rigorously define, test, and refine what “market regime” means for your strategies—using the technical features that matter most to you. Optimize your signal generation by backtesting across a universe of meaningful indicator blends. Enhance risk management with objective, real-time regime boundaries. Accelerate your research: iterate quickly, swap indicator components, and see results with minimal code changes. Automate multi-asset or pairs-trading by integrating regime context directly into strategy logic. Add both scripts to your chart, connect your preferred features, and start investigating your best regime-based trades—entirely within the TradingView ecosystem. References & Further Reading Ang, A., & Bekaert, G. (2002). “Regime Switches in Interest Rates.” Journal of Business & Economic Statistics, 20(2), 163–182. Hamilton, J. D. (1989). “A New Approach to the Economic Analysis of Nonstationary Time Series and the Business Cycle.” Econometrica, 57(2), 357–384. Markov, A. A. (1906). "Extension of the Limit Theorems of Probability Theory to a Sum of Variables Connected in a Chain." The Notes of the Imperial Academy of Sciences of St. Petersburg. Guidolin, M., & Timmermann, A. (2007). “Asset Allocation under Multivariate Regime Switching.” Journal of Economic Dynamics and Control, 31(11), 3503–3544. Murphy, J. J. (1999). Technical Analysis of the Financial Markets. New York Institute of Finance. Brock, W., Lakonishok, J., & LeBaron, B. (1992). “Simple Technical Trading Rules and the Stochastic Properties of Stock Returns.” Journal of Finance, 47(5), 1731–1764. Zucchini, W., MacDonald, I. L., & Langrock, R. (2017). Hidden Markov Models for Time Series: An Introduction Using R (2nd ed.). Chapman and Hall/CRC. On Quantitative Finance and Markov Models: Lo, A. W., & Hasanhodzic, J. (2009). The Heretics of Finance: Conversations with Leading Practitioners of Technical Analysis. Bloomberg Press. Patterson, S. (2016). The Man Who Solved the Market: How Jim Simons Launched the Quant Revolution. Penguin Press. TradingView Pine Script Documentation: www.tradingview.com TradingView Blog: “Use an Input From Another Indicator With Your Strategy” www.tradingview.com GeeksforGeeks: “What is the Difference Between Markov Chains and Hidden Markov Models?” www.geeksforgeeks.org What makes this indicator original and unique? - On‑chart, real‑time Markov. The chain is drawn directly on your chart. You see the current regime, its tendency to stay (self‑loop), and the usual next step (arrows) as bars confirm. - Source‑agnostic by design. The engine runs on any series you select via input.source() — price, your own oscillator, a composite score, anything you compute in the script. - Automatic normalization + regime mapping. Different inputs live on different scales. The script standardizes your chosen source and maps it into clear regimes (e.g., Bull / Bear / Neutral) without you micromanaging thresholds each time. - Rolling, bar‑by‑bar learning. Transition tendencies are computed from a rolling window of confirmed bars. What you see is exactly what the market did in that window. - Fast experimentation. Switch the source, adjust the window, and the Markov view updates instantly. It’s a rapid way to test ideas and feel regime persistence/switch behavior. Integrate your own signals (using input.source()) - In settings, choose the Source . This is powered by input.source() . - Feed it price, an indicator you compute inside the script, or a custom composite series. - The script will automatically normalize that series and process it through the Markov engine, mapping it to regimes and updating the on‑chart spheres/arrows in real time. Credits: Deep gratitude to @RicardoSantos for both the foundational Markov chain processing engine and inspiring open-source contributions, which made advanced probabilistic market modeling accessible to the TradingView community. Special thanks to @Alien_Algorithms for the innovative and visually stunning 3D sphere logic that powers the indicator’s animated, regime-based visualization. Disclaimer This tool summarizes recent behavior. It is not financial advice and not a guarantee of future results.
Pine Script® indicator
by Fractalyst
7